#ifndef AI_ENERGY_ANALYZER_H
#define AI_ENERGY_ANALYZER_H

#include <Arduino.h>

// 电力数据结构
typedef struct {
  unsigned long timestamp; // 时间戳
  float voltage;           // 电压 (V)
  float current;           // 电流 (A)
  float power;             // 功率 (W)
  float energy;            // 电能 (kWh)
} PowerData;

// 异常类型
enum AnomalyType {
  NO_ANOMALY = 0,
  OVERLOAD = 1,
  UNEXPECTED_USAGE = 2,
  POWER_SURGE = 3
};

// 建议类型
enum RecommendationType {
  NO_RECOMMENDATION = 0,
  REDUCE_POWER = 1,
  SCHEDULE_OPERATION = 2,
  MAINTENANCE_CHECK = 3
};

// 能源洞察结构
typedef struct {
  bool hasAnomaly;           // 是否检测到异常
  int anomalyType;           // 异常类型
  bool hasRecommendation;    // 是否有节能建议
  int recommendationType;    // 建议类型
  String recommendationText; // 建议文本
  bool autoOptimize;         // 是否自动优化
  float estimatedSavings;    // 估计节省量 (kWh/月)
} EnergyInsight;

class AIEnergyAnalyzer {
private:
  // 历史数据缓冲区大小
  static const int HISTORY_SIZE = 60; // 1小时的数据（每分钟一条）
  
  // 历史数据缓冲区
  PowerData history[HISTORY_SIZE];
  int historyIndex; // 缓冲区索引
  
  // 用电模式识别参数
  float peakPowerThreshold;  // 峰值功率阈值
  float baselinePower;       // 基线功率
  
  // 异常检测参数
  float overloadThreshold;   // 过载阈值
  float surgeThreshold;      // 浪涌阈值
  
  // 用电模式
  float dailyUsagePattern[24]; // 每天24小时的平均用电量模式
  bool isUsagePatternLearned;  // 是否已学习用电模式
  
  // 计算平均值
  float calculateAverage(float* values, int size);
  
  // 计算标准差
  float calculateStandardDeviation(float* values, int size, float mean);
  
  // 检测异常用电
  bool detectAnomaly(PowerData data, int& anomalyType);
  
  // 生成节能建议
  bool generateRecommendation(PowerData data, EnergyInsight& insight);
  
  // 学习用电模式
  void learnUsagePattern();
  
  // 预测未来用电量
  float predictFutureUsage(int hoursAhead);
  
  // 计算估计节省量
  float calculateEstimatedSavings(EnergyInsight insight);
  
public:
  // 构造函数
  AIEnergyAnalyzer();
  
  // 初始化AI分析器
  void init();
  
  // 分析能源数据
  EnergyInsight analyze(PowerData data);
  
  // 设置阈值参数
  void setThresholds(float peakThreshold, float overloadThreshold, float surgeThreshold);
  
  // 启用/禁用自动优化
  void enableAutoOptimize(bool enable);
  
  // 获取学习状态
  bool isPatternLearned();
  
  // 重置学习数据
  void resetLearning();
}; // 类定义结束

// 构造函数
AIEnergyAnalyzer::AIEnergyAnalyzer() {
  // 初始化历史数据缓冲区
  for (int i = 0; i < HISTORY_SIZE; i++) {
    history[i].timestamp = 0;
    history[i].voltage = 0.0;
    history[i].current = 0.0;
    history[i].power = 0.0;
    history[i].energy = 0.0;
  }
  
  historyIndex = 0;
  
  // 设置默认阈值
  peakPowerThreshold = 1000.0; // 1000W作为峰值功率阈值
  baselinePower = 100.0;      // 100W作为基线功率
  overloadThreshold = 1500.0; // 1500W作为过载阈值
  surgeThreshold = 250.0;     // 250V作为电压浪涌阈值
  
  // 初始化用电模式
  for (int i = 0; i < 24; i++) {
    dailyUsagePattern[i] = 0.0;
  }
  
  isUsagePatternLearned = false;
}

// 初始化AI分析器
void AIEnergyAnalyzer::init() {
  Serial.println("AI能源分析器已初始化");
}

// 计算平均值
float AIEnergyAnalyzer::calculateAverage(float* values, int size) {
  float sum = 0.0;
  for (int i = 0; i < size; i++) {
    sum += values[i];
  }
  return sum / size;
}

// 计算标准差
float AIEnergyAnalyzer::calculateStandardDeviation(float* values, int size, float mean) {
  float sumSquaredDifferences = 0.0;
  for (int i = 0; i < size; i++) {
    sumSquaredDifferences += pow(values[i] - mean, 2);
  }
  return sqrt(sumSquaredDifferences / size);
}

// 检测异常用电
bool AIEnergyAnalyzer::detectAnomaly(PowerData data, int& anomalyType) {
  bool hasAnomaly = false;
  
  // 检查过载
  if (data.power > overloadThreshold) {
    anomalyType = OVERLOAD;
    hasAnomaly = true;
  }
  
  // 检查电压浪涌
  if (data.voltage > surgeThreshold) {
    anomalyType = POWER_SURGE;
    hasAnomaly = true;
  }
  
  // 检查异常用电模式（如果已学习）
  if (isUsagePatternLearned && !hasAnomaly) {
    // 获取当前小时
    time_t currentTime = data.timestamp;
    struct tm* timeinfo = localtime(&currentTime);
    int hour = timeinfo->tm_hour;
    
    // 检查当前用电是否与模式偏差过大
    float patternPower = dailyUsagePattern[hour];
    float deviation = abs(data.power - patternPower) / patternPower;
    
    if (deviation > 0.5) { // 如果偏差超过50%，视为异常
      anomalyType = UNEXPECTED_USAGE;
      hasAnomaly = true;
    }
  }
  
  return hasAnomaly;
}

// 生成节能建议
bool AIEnergyAnalyzer::generateRecommendation(PowerData data, EnergyInsight& insight) {
  bool hasRecommendation = false;
  
  // 检查是否超过峰值功率阈值
  if (data.power > peakPowerThreshold) {
    insight.recommendationType = REDUCE_POWER;
    insight.recommendationText = "当前用电负荷过高，建议关闭不必要的设备以降低能耗。";
    hasRecommendation = true;
  }
  
  // 检查是否存在待机能耗过高的情况
  if (data.power > baselinePower * 1.5) { // 如果超过基线功率的1.5倍
    insight.recommendationType = REDUCE_POWER;
    insight.recommendationText = "检测到待机能耗过高，建议关闭不使用的设备电源。";
    hasRecommendation = true;
  }
  
  // 如果已学习用电模式，可以生成更精确的建议
  if (isUsagePatternLearned && !hasRecommendation) {
    // 此处可以添加基于用电模式的更智能建议
    // 例如：建议在用电低谷时段运行高能耗设备
  }
  
  return hasRecommendation;
}

// 学习用电模式
void AIEnergyAnalyzer::learnUsagePattern() {
  // 收集足够的数据后学习用电模式
  int validDataPoints = 0;
  for (int i = 0; i < HISTORY_SIZE; i++) {
    if (history[i].timestamp > 0) {
      validDataPoints++;
    }
  }
  
  // 如果有足够的数据点，则开始学习
  if (validDataPoints >= HISTORY_SIZE * 0.8) { // 至少80%的数据点有效
    // 重置每日用电模式
    for (int i = 0; i < 24; i++) {
      dailyUsagePattern[i] = 0.0;
    }
    
    int hourCount[24] = {0}; // 记录每小时的数据点数量
    
    // 计算每小时的平均用电量
    for (int i = 0; i < HISTORY_SIZE; i++) {
      if (history[i].timestamp > 0) {
        time_t currentTime = history[i].timestamp;
        struct tm* timeinfo = localtime(&currentTime);
        int hour = timeinfo->tm_hour;
        
        dailyUsagePattern[hour] += history[i].power;
        hourCount[hour]++;
      }
    }
    
    // 计算平均值
    for (int i = 0; i < 24; i++) {
      if (hourCount[i] > 0) {
        dailyUsagePattern[i] /= hourCount[i];
      }
    }
    
    isUsagePatternLearned = true;
    Serial.println("用电模式学习完成");
  }
}

// 预测未来用电量
float AIEnergyAnalyzer::predictFutureUsage(int hoursAhead) {
  if (!isUsagePatternLearned) {
    return 0.0; // 如果尚未学习用电模式，无法预测
  }
  
  // 获取当前时间
  time_t now = time(nullptr);
  struct tm* timeinfo = localtime(&now);
  int currentHour = timeinfo->tm_hour;
  
  // 预测未来指定小时的用电量
  int futureHour = (currentHour + hoursAhead) % 24;
  return dailyUsagePattern[futureHour];
}

// 计算估计节省量
float AIEnergyAnalyzer::calculateEstimatedSavings(EnergyInsight insight) {
  float estimatedSavings = 0.0;
  
  // 根据建议类型估计节省量
  switch (insight.recommendationType) {
    case REDUCE_POWER:
      // 假设减少10-30%的能耗
      estimatedSavings = random(10, 31) / 100.0 * 100.0; // 估计每月节省10-30 kWh
      break;
    case SCHEDULE_OPERATION:
      // 假设通过调度运行节省5-15%的能耗
      estimatedSavings = random(5, 16) / 100.0 * 100.0; // 估计每月节省5-15 kWh
      break;
    case MAINTENANCE_CHECK:
      // 假设通过维护节省3-10%的能耗
      estimatedSavings = random(3, 11) / 100.0 * 100.0; // 估计每月节省3-10 kWh
      break;
  }
  
  return estimatedSavings;
}

// 分析能源数据
EnergyInsight AIEnergyAnalyzer::analyze(PowerData data) {
  EnergyInsight insight;
  insight.hasAnomaly = false;
  insight.anomalyType = NO_ANOMALY;
  insight.hasRecommendation = false;
  insight.recommendationType = NO_RECOMMENDATION;
  insight.recommendationText = "";
  insight.autoOptimize = true; // 默认启用自动优化
  insight.estimatedSavings = 0.0;
  
  // 更新历史数据缓冲区
  history[historyIndex] = data;
  historyIndex = (historyIndex + 1) % HISTORY_SIZE;
  
  // 学习用电模式
  learnUsagePattern();
  
  // 检测异常
  int anomalyType;
  insight.hasAnomaly = detectAnomaly(data, anomalyType);
  if (insight.hasAnomaly) {
    insight.anomalyType = anomalyType;
  }
  
  // 生成节能建议
  insight.hasRecommendation = generateRecommendation(data, insight);
  if (insight.hasRecommendation) {
    insight.estimatedSavings = calculateEstimatedSavings(insight);
  }
  
  return insight;
}

// 设置阈值参数
void AIEnergyAnalyzer::setThresholds(float peakThreshold, float overloadThreshold, float surgeThreshold) {
  this->peakPowerThreshold = peakThreshold;
  this->overloadThreshold = overloadThreshold;
  this->surgeThreshold = surgeThreshold;
}

// 启用/禁用自动优化
void AIEnergyAnalyzer::enableAutoOptimize(bool enable) {
  // 在EnergyInsight结构体中设置
}

// 获取学习状态
bool AIEnergyAnalyzer::isPatternLearned() {
  return isUsagePatternLearned;
}

// 重置学习数据
void AIEnergyAnalyzer::resetLearning() {
  isUsagePatternLearned = false;
  for (int i = 0; i < 24; i++) {
    dailyUsagePattern[i] = 0.0;
  }
  Serial.println("用电模式学习数据已重置");
}

#endif // AI_ENERGY_ANALYZER_H